I/O. Output. Input. Input ของจาวา จะเป น stream จะอ าน stream ใช คลาส Scanner. standard input. standard output. standard err. command line file.

Transcription

1 I/O and Exceptions

2 I/O Input standard input keyboard (System.in) command line file Output standard output Screen (System.out) standard err file System.err Input ของจาวา จะเป น stream จะอ าน stream ใช คลาส Scanner 2

3 Input Scanner Scanner in = new Scanner( input stream ); จะอ านจากไหนก ใส input stream เป นอ นน น เช น อ านจาก keyboard new Scanner(System.in) อ านจาก file ต องสร าง FileReader new Scanner(new FileReader(ช อไฟล )) 3

4 อ านจาก internet import java.net.url; // ใน main URL url = new URL(" Scanner in = new Scanner(url.openStream());... in.close(); 4

5 Scanner hasnext() nextint() nextdouble() next() nextline() 5

6 Print to file สร าง PrintStream หร อ สร าง PrintWriter (แบบใหม ) PrintWriter out = new PrintWriter(ช อไฟล ); out.print( ); out.println( ); out.close(); 6

7 Error Handling with Exceptions Java: Badly-formed code will not be run Ideal catch at compile time Fact not all errors can be detected at compile time. They must be handled at run time Run-time error handling integrated into the core of the language, enforced by the compiler 7

8 The problem Dealing with errors during program execution What causes errors? Program logic (i.e.: exceeding array bounds) Can be fixed by the programmer Status of the environment (i.e.: network goes down) out of control by the programmer 8

9 What is an exception? เหต การณ (ผ ดปกต ) ท ทาให การทางานของ โปรแกรมหย ดชะง ก ในจาวาเป น object ซ งคอยส งส ญญาณ error condition และให ข อม ลเก ยวก บ error. Enforced by the Java compiler (cannot be ignored). 9

10 Advantages แยกส วนท เป น error handling code ออกจาก ส วนอ นๆ เร ยกว า exception handler ทาให อ าน ง าย Propagating errors up the call stack Grouping error types and error differentiation 10

11 Advantage 1 Separating error handling code from regular code and handling all the problems in only one place, called exception handler. // pseudo-code of a function readfile { open the file; determine its size; allocate that much memory; read the file into memory; close the file; C. Patanothai 11

12 Traditional error management (1) Potential errors What happens if the file can t be opened? What happens if the length of the file can t be determined? What happens if enough memory can t be allocated? What happens if the read fails? What happens if the file can t be closed? Putting error detections into your regular code can lead to confusing spaghetti code. 12

13 Traditional error management (2) errorcodetype readfile { initialize errorcode = 0; open the file; if (thefileisopen) { determine the length of the file; if (gotthefilelength) { allocate that much memory; if (gotenoughmemory) { read the file into memory; if (readfailed) errorcode = -1; // read failed else errorcode = -2; // not enough memory else errorcode = -3; // file size can t be determined close the file; if (thefiledidntclose && errorcode == 0) { errorcode = -4; // can t close file else errorcode = errorcode and -4; // can t close file + error else errorcode = -5; // can t open file return errorcode; 13

14 Using exception handling readfile { try { open the file; determine its size; allocate that much memory; read the file into memory; close the file; catch (fileopenfailed) { dosomething; catch (sizedeterminationfailed) { dosomething; catch (memoryallocationfailed) { dosomething; catch (readfailed) { dosomething; catch (fileclosefailed) { dosomething; 14

15 Advantage 2 Propagating errors up the call stack Suppose that only method1 is interested in error from readfile. method1 { call method2; method2 { call method3; method3 { call readfile; 15

16 Without exception method1 { errorcodetype error; error = call method2; if (error) doerrorprocessing; else proceed; method2 { errorcodetype error; error = call method3; if (error) return error; else proceed; method3 { errorcodetype error; error = call readfile; if (error) return error; else proceed; 16

17 With exception method1 { try { call method2; catch (exception) { doerrorprocessing; method2 throws exception { call method3; method3 throws exception { call readfile; 17

18 Advantage 3 Grouping error types and error differentiation All exceptions are subclass of Throwable class Exception ArrayException InvalidIndexException NoSuchElementException ElementTypeException 18

19 Advantage 3 (ต อ) If interested in a specific exception catch (InvalidIndexException e) {... If interested in all exceptions about array catch (ArrayException e) {... We can catch either specific exceptions or general exceptions or both. 19

20 Throwing an Exception ถ าเราไม ม ข อม ลท จะจ ดการก บ exception ท เก ดข นได เราก จะโยนต อ throw an exception: if (t == null) throw new NullPointerException(); Exception arguments if (t == null) ช อของ class จะบอกประเภทของ exception throw new NullPointerException( t=null ); 20

21 Termination vs. Resumption In termination, you don t want to deal with the error, so you throw the exception. If a method chooses not to catch an exception, the method must specify (in its signature) that it can throw that exception. public void doxxx() throws SomeException {... In resumption, you presume that it will be successful the second time. Put the try block inside an infinite while loop until the result is satisfied. 21

22 Class hierarchy for error handling System & JVM Errors Object Throwable Can throw objects of any Throwable-derived class Error Exception Exception-derived classes RunTimeException Error-derived classes other derived classes 22

23 Checked vs. Unchecked Checked Exceptions must be specified to handle or pass on exceptions that are expected to happen forced by compiler Unchecked Exceptions exceptions derived from RuntimeException 23

24 Class hierarchy for error handling Object checked Throwable Error Exception Error-derived classes RunTimeException Exception-derived classes unchecked other derived classes 24

25 The exception specification It s a part of the method declaration, appearing after the argument list. void f() throws Exception1, Exception2,..., ExceptionN { //... 25

26 Catching an Handling Exceptions (1) The try block: a guarded region try { // code that may // generate exceptions A try statement must be accompanied by at least one catch block or one finally block. 26

27 Catching an Handling Exceptions (2) The catch block(s): exception handler try { // code that might generate exceptions catch (Type1 id1) { // handle exceptions of Type1 catch (Type2 id2) { // handle exceptions of Type2 catch (Type3 id3) { // handle exceptions of Type3 // etc... ไม ต องม คำส ง break ต ำงจำก switch-case 27

28 Catching an Handling Exceptions (3) The finally block: clean up mechanism try { // code that might generate exceptions catch (Type1 id1) { // handle exceptions of Type1 catch (Type2 id2) { // handle exceptions of Type2 catch (Type3 id3) { // handle exceptions of Type3 finally { // code guarantee // to be executed 28

29 class ThreeException extends Exception { public class FinallyWorks { static int count = 0; public static void main(string[] args) { while (true) { try { // post-increment is zero first time: if (count++ == 0) throw new ThreeException(); System.out.println( No exception ); catch (ThreeException e) { System.out.println( ThreeException ); finally { System.out.println( In finally clause ); if (count == 2) break; ThreeException In finally clause No exception In finally clause 29

30 What s finally for? Always gets called, regardless of what happens with the exception and where it s caught To set something other than memory back to its original state (GC handles memory) (close files, network connections, etc.) 30

31 try { openfile(); readfile(); closefile(); catch (Exception1 e) { // handle exception1 closefile(); catch (Exception2 e) { // handle exception2 closefile(); try { duplicate closefile() If new catch is added, closefile() must be called. more error-prone openfile(); readfile(); catch (Exception1 e) { // handle exception1 catch (Exception2 e) { // handle exception2 finally { closefile(); 31

32 Rethrowing an exception You may want to rethrow the exception that you just caught, or throw a new exception. catch (Exception1 e) { System.err.println( An exception was thrown ); throw e; catch (Exception1 e) { System.err.println( An exception was thrown ); throw new Exception2(); 32

33 Creating your own exceptions Choosing the exception type to throw Use one written by someone else Write one of your own Choosing a superclass Must be a subclass of Throwable Error Exception or Exception-derived class Naming conventions Having Exception to the end of all Exception-derived classes Having Error to the end of Error-derived classes 33

34 Creating your own exceptions class InvalidCharException extends Exception { class InvalidCharException extends Exception { public InvalidCharException() { public InvalidCharException(String msg) { super(msg); 34

35 Exception matching Only one catch block will be executed Sequential search in the order they are written Does not required a perfect match Is the thrown exception is-a object of the exception in the catch block? No continue searching Yes exception match 35

36 class GenericException extends Exception { class SpecificException extends GenericException { class AnotherSpecificException extends GenericException { class MoreSpecificException extends SpecificException { catch (MoreSpecificException e) { //... catch (SpecificException e) { //... catch (AnotherSpecificException e) { //... catch (GenericException e) { //... finally { //... match if an object of SpecificationException is thrown 36

37 class GenericException extends Exception { class SpecificException extends GenericException { class AnotherSpecificException extends GenericException { class MoreSpecificException extends SpecificException { catch (MoreSpecificException e) { //... catch (AnotherSpecificException e) { //... catch (SpecificException e) { //... catch (GenericException e) { //... finally { //... if an object of GenericException is thrown 37

38 class GenericException extends Exception { class SpecificException extends GenericException { class AnotherSpecificException extends GenericException { class MoreSpecificException extends SpecificException { catch (GenericException e) { //... catch (AnotherSpecificException e) { //... catch (SpecificException e) { //... catch (MoreSpecificException e) { //... finally { //... if an object of SpecificationException is thrown 38

39 Exception matching Catch the most specific exception (leaf node of the hierarchy) first. Go up the hierarchy Put the most generic one (base-class) at the very last catch block Base-class handler will catch derivedclass object 39

40 Overhead Exceptions are free as long as they don t get thrown If they are thrown, very expensive Don t use exceptions for normal flow of control Only use exceptions to indicate abnormal conditions 40

41 Guidelines Handle an exception only if you have enough information to correct the error let the exception propagate up (throw it) Separate error handling code (which almost never runs) from the code that represents the normal path of execution Make code more readable 41

42 Guidelines Handle tasks, not statements put tasks inside of a try block Use loops to retry If you catch an exception, do something with it Clean up using finally Use exception in constructors sometimes construction does not succeed 42